package com.xlh.controller;

import cn.hutool.core.lang.Console;
import com.google.common.collect.Lists;
import com.xlh.dto.courseTest.UserCourseTestInfoDTO;
import com.xlh.dto.courseTest.experiment.ExperimentStatisticsTaskPassDTO;
import com.xlh.dto.courseTest.experiment.UserExperimentTimeInfoDTO;
import com.xlh.dto.courseTest.practice.PrictceCourseStatisticsDTO;
import com.xlh.dto.problem.UserProblemAndAnswerDTO;
import com.xlh.dto.quiz.UserQuizStatusDTO;
import com.xlh.pojo.course.TheoryLearnTimeStatistics;
import com.xlh.pojo.courseTest.ExperimentReport;
import com.xlh.pojo.support.Statistics;
import com.xlh.service.courseTest.*;
import com.xlh.service.problem.ProblemService;
import com.xlh.support.attendance.service.AttendanceService;
import com.xlh.support.quiz.service.QuizStatisticService;
import com.xlh.virtualization.service.ImageAllocationService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author sy
 */
@RestController
@Api(tags = "CourseStatisticsTest", description = "测试controller类")
@Slf4j
public class CourseStatisticsTest {

    /**
     * 实验类
     */
    @Autowired
    private ExperimentReportService experimentReportService;

    /**
     * 练习接口
     */
    @Autowired
    private PracticeService practiceService;

    /**
     * 学生旷课次数
     */
    @Autowired
    private AttendanceService attendanceService;

    /**
     *问题交流
     */
    @Autowired
    private ProblemService problemService;


    /**
     * 考试实体类
     */
    @Autowired
    private PaperAnswerSheetService paperAnswerSheetService;


    /**
     * 随堂提问
     */
    @Autowired
    private QuizStatisticService quizStatisticService;


    /**
     * 理论课时长service
     */
    @Autowired
    private TheoryService theoryService;


    /**
     * 实验
     */
    @Autowired
    private ExperimentStatisticsTaskPassService experimentStatisticsTaskPassService;


    /**
     * 查询随堂练习统计接口Service
     */
    @Autowired
    private QuestionRepositoryService questionRepositoryService;



    /**
     * 查询实验统计时长
     */
    @Autowired
    private ExperimentVideoStatisticsService experimentVideoStatisticsService;

    /**
     * 镜像的接口
     */
    @Autowired
    private ImageAllocationService imageAllocationService;


    private static List<Long> userId = Lists.newArrayList(91L,92L,93L,94L,95L,96L,97L,98L,99L,100L,101L);

    //private static List<Long> userId = Lists.newArrayList(101L);

    private static List<Long> taskIds = Lists.newArrayList(10951L,10593L);

    private static Long courseId = 166L;

    private static List<Long> chapterIds  = Lists.newArrayList(10891L,10892L,10894L,10896L,10898L);

    private static Long classId = 591L;


    /**
     * 接口1： 我给你章节id集合， 你返回给我 教师端配置了随堂练习的章节id集合
     * 参数：List<Long> chapterIds
     * 返回：List<Long> chapterIds 如果不给我List<Long>  就给我List<对象> 我这边自己过滤出来 chapterids 也可以。
     */
    @GetMapping("/findHavePracticeChapterIds")
    @ApiOperation("是否有随堂练习")
    public void findHavePracticeChapterIds(){
        List<Long> chapterIds  = Lists.newArrayList(11019L, 11020L, 11021L, 11022L);
        List<Long> havePracticeChapterIds = questionRepositoryService.findHavePracticeChapterIds(chapterIds);
        Console.log(" ------ 是否有随堂练习接口 -------");
        Console.log(havePracticeChapterIds);

    }


    /**
     * 接口1： 我给你章节id集合， 你返回给我 教师端配置了随堂练习的章节id集合
     * 参数：List<Long> chapterIds
     * 返回：List<Long> chapterIds 如果不给我List<Long>  就给我List<对象> 我这边自己过滤出来 chapterids 也可以。
     */
    @PostMapping("/commonTest")
    @ApiOperation("删除考试 移动练习")
    public void commonTest()  {

        // TODO SpringContextUtil.getBean(serviceName).getClass().getMethod(methodName).invoke(SpringContextUtil.getBean(serviceName), );
        questionRepositoryService.moveQuestionToSpecifyUser(Lists.newArrayList(2936L), 8L);
        Long longs = 2936L;

    }


     /* 接口2：我给你任务id集合，你返回给我 教师端配置了虚机的任务id集合
     * 参数：List<Long> taskIds
     * 返回：List<Long> taskIds  如果不给我List<Long>  就给我List<对象> 我这边自己过滤出来 taskId 也可以。
     */
     @GetMapping("/findHaveImagesByTaskIds")
     @ApiOperation("任务是否有实验镜像")
    public void findHaveImagesByTaskIds(){
        List<Long> taskIds = Lists.newArrayList(11015L, 11016L, 11017L,11018L);
        List<Long> haveImageTasks = imageAllocationService.getHaveImageTasks(taskIds);
        Console.log(" ------ 是否有实验镜像 -------");
         Console.log(haveImageTasks);
    }
    /**
     * 查询实验视频时长问题
     */
    @GetMapping(value = "findLearnAndVideoTimeTest")
    public void findLearnAndVideoTimeTest(){

        List<UserExperimentTimeInfoDTO> learnAndVideoTime = experimentVideoStatisticsService.findLearnAndVideoTime(courseId, classId, userId, taskIds);
        learnAndVideoTime.forEach(x -> log.info(x.toString()));

    }


    /**
     * 接口：0
     * 获取某个课程下学生各自的视频总时长 和 学习总时长
     * 参数：Long courseId 、Long classId 、List<Long> userId
     * 返回值：List<对象>  对象中必须包含 courseId 、classId、userId、视频总时长单位是秒 、 学习总时长单位是秒
     */
    @GetMapping(value = "findVideoSumInfoTest")
    public void findVideoSumInfoTest(){

        Long courseId = 163L;
        Long classId = 591L;

        List<TheoryLearnTimeStatistics> videoSumInfo = theoryService.findVideoSumInfo(courseId, classId, userId, chapterIds);

        for (TheoryLearnTimeStatistics theoryLearnTimeStatistics : videoSumInfo) {
            log.info(theoryLearnTimeStatistics.toString());
        }

    }

    /**
     * 接口：获取某个课程下每个任务的 学生的实验判定通过状态
     *
     * 参数：Long courseId 、Long classId 、List<Long> taskIds 、 List<Long> userIds
     * 返回值：List<对象>  对象中必须包含 courseId 、classId、任务id、userId、实验判定通过状态（最好给我boolean类型）
     */
    @GetMapping(value = "findExperimentByUserIdTest")
    public void findExperimentByUserIdTest(){

        List<ExperimentStatisticsTaskPassDTO> experimentByUserId = experimentStatisticsTaskPassService.findExperimentByUserId(courseId, classId, taskIds, userId);

        for (ExperimentStatisticsTaskPassDTO experimentStatisticsTaskPassDTO : experimentByUserId) {
            log.info(experimentStatisticsTaskPassDTO.toString());
        }
    }

    /**
     * 接口2：实验报告（查询未删除的）
     *
     * 表：experiment_report
     * 目的：查询每个学生的各个实验的实验报告情况
     * 参数：List<Long> userIds 、 List<Long> taskIds
     * 返回值：List<实验报告对象> 必须包含：提交状态、评分、任务id、userId
     */
    @GetMapping(value = "testFindReportByUserIdsAndTaskIds")
    public void testFindReportByUserIdsAndTaskIds(){

        List<ExperimentReport> reportByUserIdsAndTaskIds = experimentReportService.findReportByUserIdsAndTaskIds(userId, taskIds);

        for (ExperimentReport reportByUserIdsAndTaskId : reportByUserIdsAndTaskIds) {
            log.info(reportByUserIdsAndTaskId.getUserId()+"userID"+ reportByUserIdsAndTaskId.getChapterId());
        }
    }

    /**
     * 接口3：随堂练习（查询未删除的）
     *
     * 表：practice
     * 目的：查询每个学生的各个章节的随堂练习情况
     * 参数：List<Long> chapterIds 、 List<Long> userIds
     * 返回值：List<随堂练习对象> 必须包含：提交状态、评分、章节id、userId
     */
    @GetMapping(value = "findPracticeByChapterIdsAndUserIdsTest")
    public void findPracticeByChapterIdsAndUserIdsTest(){

        Console.log("------1111-------" + chapterIds.size()*userId.size() + "-------------" );
        Console.log("------1111-------" + chapterIds.size()*userId.size() + "-------------" );
        Console.log("------1111-------" + chapterIds.size()*userId.size() + "-------------" );
        Console.log("------1111-------" + chapterIds.size()*userId.size() + "-------------" );

        List<PrictceCourseStatisticsDTO> practiceByChapterIdsAndUserIds = practiceService.findPracticeByChapterIdsAndUserIds(chapterIds, userId);

        for (PrictceCourseStatisticsDTO practiceByChapterIdsAndUserId : practiceByChapterIdsAndUserIds) {
            log.info( "ChapterId()" + practiceByChapterIdsAndUserId.getChapterId() +
                    "UserId"+practiceByChapterIdsAndUserId.getUserId()+
                    "错题数"+practiceByChapterIdsAndUserId.getObjectiveItemCount()+"正确数111量"+practiceByChapterIdsAndUserId.getObjectiveItemErrorCount());
        }


    }

    /**
     * 接口4：考勤（查询未删除）
     *
     * 表：statistics
     * 目的：查询每个学生的考勤情况
     * 参数：Long courseId 、 Long classId、List<Long> userIds
     * 返回值：List<考勤对象> 必须包含：旷课数、courseId、classId、userId
     */
    @GetMapping(value = "findAttendanceByUserIdsTest")
    public void findAttendanceByUserIdsTest(){

        List<Statistics> attendanceByUserIds = attendanceService.findAttendanceByUserIds(courseId, classId, userId);

        for (Statistics attendanceByUserId : attendanceByUserIds) {
            log.info(attendanceByUserId.toString());
        }
    }

    /**
     * 接口5：问题交流（查询未删除）
     *
     * 表：pc_problem、pc_reply
     * 目的：查询每个学生的问题交流情况
     * 参数：Long courseId、List<Long> userIds
     * 返回值：List<问题交流对象> 必须包含：提问问题总数、回答问题总数、courseId、userId
     */
    @GetMapping(value = "findProblemAndAnswerInfoByUserTest")
    public void findProblemAndAnswerInfoByUserTest(){

        List<UserProblemAndAnswerDTO> problemAndAnswerInfoByUser = problemService.findProblemAndAnswerInfoByUser(courseId, userId);
        for (UserProblemAndAnswerDTO userProblemAndAnswerDTO : problemAndAnswerInfoByUser) {
            log.info(userProblemAndAnswerDTO.toString());
        }
    }


    /**
     *接口6：考试（查询未删除）
     *
     * 表：course_test_paper 【可能还得有其他表】
     * 目的：查询每个学生的考试情况
     * 参数：Long courseId、Long classId 、List<Long> userIds
     * 返回值：List<考试对象> 必须包含：考试id、考试名称、学生分数、试卷总分、考试时间、courseId、classId、userId
     */
    @GetMapping(value = "paperAnswerSheetServiceTest")
    public void paperAnswerSheetServiceTest(){

        List<UserCourseTestInfoDTO> testStatisticsByUserIds = paperAnswerSheetService.findTestStatisticsByUserIds(courseId, classId, userId);

        for (UserCourseTestInfoDTO testStatisticsByUserId : testStatisticsByUserIds) {
            log.info(testStatisticsByUserId.toString());
        }

    }

    /**
     * 接口7：随堂提问（查询未删除）
     *
     *     表：support_quiz、support_quiz_answer
     *     目的：查询每个学生的随堂练习情况
     *     参数：List<Long> chapterIds、List<Long> userIds
     *     返回值：List<随堂提问对象> 必须包含：chapterId、userId、答题情况
     */
    @GetMapping(value = "findQuizStatisticByUserIdsTest")
    public void findQuizStatisticByUserIdsTest(){

        List<UserQuizStatusDTO> quizStatisticByUserIds = quizStatisticService.findQuizStatisticByUserIds(chapterIds, userId);

        for (UserQuizStatusDTO quizStatisticByUserId : quizStatisticByUserIds) {
            log.info(quizStatisticByUserId.toString());
        }

    }








}
